
/**
 * 
 * 计算网络信号
 * 
 * 题目描述

网络信号经过传递会逐层衰减，且遇到阻隔物无法直接穿透，在此情况下需要计算某个位置的网络信号值。注意:网络信号可以绕过阻隔物。

array[m][n] 的二维数组代表网格地图
array[i][j] = 0 代表 i 行 j 列是空旷位置
array[i][j] = x（x为正整数）代表 i 行 j 列是信号源，信号强度是 x
array[i][j] = -1代表i行j列是阻隔物
信号源只有 1 个，阻隔物可能有 0 个或多个
网络信号衰减是上下左右相邻的网格衰减 1
现要求输出对应位置的网络信号值。

输入描述
输入为三行：

第一行为 m 、n ，代表输入是一个 m × n 的数组
第二行是一串 m × n 个用空格分隔的整数，每连续 n 个数代表一行，再往后 n 个代表下一行，以此类推。对应的值代表对应的网格是空旷位置，还是信号源，还是阻隔物。
第三行是 i 、 j，代表需要计算 array[i][j] 的网络信号值。
注意：此处 i 和 j 均从 0 开始，即第一行 i 为 0。

例如

6 5
0 0 0 -1 0 0 0 0 0 0 0 0 -1 4 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0
1 4
代表如下地图



需要输出第 1 行第 4 列的网络信号值，如下图，值为 2



输出描述
输出对应位置的网络信号值，如果网络信号未覆盖到，也输出0。

一个网格如果可以途径不同的传播衰减路径传达，取较大的值作为其信号值。

备注
m 不一定等于 n，m<100，n<100，网络信号之小于 1000。
信号源只有 1 个，阻隔物可能有 0 个或多个。
输入的 m，n 与第二行的数组是合法的，无需处理数量对不上的异常情况。
要求输出信号值的位置，不会是阻隔物。

 
用例
输入	6 5
0 0 0 -1 0 0 0 0 0 0 0 0 -1 4 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 0 0
1 4
输出	2
说明	无
输入	6 5
0 0 0 -1 0 0 0 0 0 0 0 0 -1 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
2 1
输出	0
说明	无
 */

import java.util.LinkedList;
import java.util.Scanner;

/**
  * 
  题目解析
用例图示如下



 因此[1,4]位置（如上图红框位置）的值为2。

通过图示，我们可以很容易想到解题思路是图的多源BFS。

关于多源BFS可以看下：

计算疫情扩散时间-CSDN博客
https://blog.csdn.net/qfc_128220/article/details/127711317?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522E9D2A5B9-2796-4535-9D1B-D75F8EDA0327%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=E9D2A5B9-2796-4535-9D1B-D75F8EDA0327&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-127711317-null-null.nonecase&utm_term=%E8%AE%A1%E7%AE%97%E7%96%AB%E6%83%85&spm=1018.2226.3001.4450


  */

public class 计算网络信号 {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int m = sc.nextInt();
        int n = sc.nextInt();
 
        LinkedList<Integer> queue = new LinkedList<>();
 
        int[][] matrix = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
 
                if (matrix[i][j] > 0) {
                    queue.add(i * n + j);
                }
            }
        }
 
        int tx = sc.nextInt();
        int ty = sc.nextInt();
 
        // 上下左右偏移量
        int[][] offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
 
        // bfs按层扩散
        while (!queue.isEmpty()) {
            int size = queue.size();
 
            for (int i = 0; i < size; i++) {
                int pos = queue.removeFirst();
 
                int x = pos / n;
                int y = pos % n;
 
                for (int[] offset : offsets) {
                    int newX = x + offset[0];
                    int newY = y + offset[1];
 
                    if (newX >= 0 && newX < m && newY >= 0 && newY < n && matrix[newX][newY] == 0) {
                        matrix[newX][newY] = matrix[x][y] - 1;
 
                        if (matrix[newX][newY] > 0) {
                            queue.addLast(newX * n + newY);
                        }
                    }
                }
            }
        }
 
        System.out.println(matrix[tx][ty]);
    }
}
